package com.company.anr.service;

<<<<<<< HEAD
import com.company.anr.config.AnrConfig;
=======
>>>>>>> 0ee3959d6b85a6244535efdf7a63de80c9f0fab4
import com.company.anr.utils.FileUtils;
import net.lingala.zip4j.ZipFile;
import net.lingala.zip4j.exception.ZipException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
<<<<<<< HEAD
import org.springframework.beans.factory.annotation.Autowired;
=======
>>>>>>> 0ee3959d6b85a6244535efdf7a63de80c9f0fab4
import org.springframework.stereotype.Service;

import java.io.IOException;
import java.nio.file.*;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.stream.Stream;

@Service
public class FileProcessingService {

  private static final Logger logger = LoggerFactory.getLogger(FileProcessingService.class);

<<<<<<< HEAD
  @Autowired
  private AnrConfig anrConfig;

=======
>>>>>>> 0ee3959d6b85a6244535efdf7a63de80c9f0fab4
  /**
   * 解压并复制日志文件（模仿 Python 的 extract_and_copy 函数）
   * 
   * 这个方法的主要功能：
   * 1. 解压从公司内部网站下载的日志压缩包
   * 2. 筛选出有用的日志文件（anr 和 system 目录）
   * 3. 解析 ANR 日志并生成分析报告
   * 4. 清理临时文件，保持目录整洁
   * 
   * @param zipFilePath 压缩文件路径（从网站下载的 .gz 文件）
   * @param targetDir   目标目录（通常是 D:/ANR-WORK）
   * @param outputDir   输出目录（D:/ANR-WORK/<设备SN>）
   * @return 是否成功
   */
  public boolean extractAndCopy(Path zipFilePath, Path targetDir, Path outputDir) {
    try {
      // ========== 第一步：解压ZIP文件 ==========
      logger.info("开始解压文件: {}", zipFilePath);
      ZipFile zipFile = new ZipFile(zipFilePath.toFile());
<<<<<<< HEAD

=======
      
>>>>>>> 0ee3959d6b85a6244535efdf7a63de80c9f0fab4
      // 获取压缩包内所有文件的路径列表
      List<String> fileNames = zipFile.getFileHeaders().stream()
          .map(header -> header.getFileName())
          .toList();

      // 检查压缩包的顶层目录结构
      // 有些压缩包直接包含 zlog/ 目录，有些没有
      String firstDir = fileNames.isEmpty() ? "" : fileNames.get(0).split("/")[0];
      Path extractDir;

      if (!"zlog".equals(firstDir)) {
        // 如果压缩包顶层不是 zlog，则创建 zlog 目录再解压
        extractDir = targetDir.resolve("zlog");
        FileUtils.createDirectoryIfNotExists(extractDir);
        zipFile.extractAll(extractDir.toString());
        logger.info("压缩包顶层不是 zlog，解压到: {}", extractDir);
      } else {
        // 如果压缩包顶层就是 zlog，直接解压到目标目录
        extractDir = targetDir;
        zipFile.extractAll(extractDir.toString());
        logger.info("压缩包顶层是 zlog，直接解压到: {}", extractDir);
      }

      logger.info("文件解压完成: {}", extractDir);

      // ========== 第二步：删除原始压缩包 ==========
      FileUtils.safeDelete(zipFilePath);
      logger.info("已删除原始压缩包: {}", zipFilePath);

      // ========== 第三步：准备目录结构 ==========
      // 确保解压后的 zlog 目录存在
      Path extractedDir = targetDir.resolve("zlog");
      if (!Files.exists(extractedDir)) {
        logger.error("解压目录不存在: {}", extractedDir);
        return false;
      }

      // 清空并创建最终输出目录（D:/ANR-WORK/<设备SN>）
      if (Files.exists(outputDir)) {
        FileUtils.safeDelete(outputDir);
        logger.info("清空现有输出目录: {}", outputDir);
      }
      FileUtils.createDirectoryIfNotExists(outputDir);
      logger.info("创建输出目录: {}", outputDir);

      // ========== 第四步：复制有用的文件夹 ==========
      // 只复制 anr/ 和 system/ 目录下的非空子目录
      // anr/ 目录：包含慢方法分析文件（blockinfo.txt）
      // system/ 目录：包含真正的 ANR 文件（anr* 开头的文件）
      copyUsefulFolders(extractedDir, outputDir);

      // ========== 第五步：处理ANR日志 ==========
      // 解析 anr/ 目录下的 blockinfo.txt 文件，生成慢方法分析报告
      Path anrDir = outputDir.resolve("anr");
      if (Files.exists(anrDir)) {
        logger.info("开始处理 ANR 日志文件");
<<<<<<< HEAD
        processAnrFolder(anrDir, Paths.get(anrConfig.getTempLogPath()));
=======
        processAnrFolder(anrDir, targetDir.resolve("tmp_log.txt"));
>>>>>>> 0ee3959d6b85a6244535efdf7a63de80c9f0fab4
        logger.info("ANR 日志处理完成，生成报告: tmp_log.txt");
      } else {
        logger.warn("未找到 anr 目录，跳过 ANR 日志处理");
      }

      // ========== 第六步：清理临时文件 ==========
      // 删除解压后的临时 zlog 目录，保持工作目录整洁
      FileUtils.safeDelete(extractedDir);
      logger.info("清理临时目录: {}", extractedDir);

      logger.info("文件处理完成，输出目录: {}", outputDir);
      return true;

    } catch (Exception e) {
      logger.error("处理 {} 时出错: {}", zipFilePath, e.getMessage());
      return false;
    }
  }

  /**
   * 复制有用的文件夹（anr 和 system）
   * 
   * 这个方法的作用：
   * 1. 从解压后的 zlog 目录中筛选出 anr/ 和 system/ 目录
   * 2. 只复制这两个目录下的非空子目录
   * 3. 跳过空的目录，避免复制无用的文件
   * 
   * 目录说明：
   * - anr/ 目录：包含慢方法分析文件（blockinfo.txt），用于分析应用卡顿
   * - system/ 目录：包含真正的 ANR 文件（anr* 开头），用于分析应用无响应
   * 
   * @param extractedDir 解压目录（D:/ANR-WORK/zlog）
   * @param outputDir    输出目录（D:/ANR-WORK/<设备SN>）
   */
  private void copyUsefulFolders(Path extractedDir, Path outputDir) {
    // 定义需要复制的有用目录
    String[] usefulFolders = { "anr", "system" };

    for (String folderName : usefulFolders) {
      Path srcFolder = extractedDir.resolve(folderName);
<<<<<<< HEAD
      Path targetFolder = outputDir.resolve(folderName);

      // 如果源目录不存在，创建空的目标目录
      if (!Files.exists(srcFolder)) {
        logger.info("源目录不存在，创建空的{}目录: {}", folderName, targetFolder);
        try {
          Files.createDirectories(targetFolder);
        } catch (IOException e) {
          logger.error("创建空目录失败: {}, 错误: {}", targetFolder, e.getMessage());
        }
=======
      
      // 如果源目录不存在，跳过
      if (!Files.exists(srcFolder)) {
        logger.info("跳过不存在的目录: {}", srcFolder);
>>>>>>> 0ee3959d6b85a6244535efdf7a63de80c9f0fab4
        continue;
      }

      logger.info("开始处理目录: {}", srcFolder);

<<<<<<< HEAD
      // 确保目标目录存在
      try {
        Files.createDirectories(targetFolder);
      } catch (IOException e) {
        logger.error("创建目标目录失败: {}, 错误: {}", targetFolder, e.getMessage());
        continue;
      }

      try (Stream<Path> paths = Files.list(srcFolder)) {
        paths.filter(Files::isDirectory) // 只处理目录
            .filter(path -> !FileUtils.isDirectoryEmpty(path)) // 只复制非空目录
            .forEach(srcPath -> {
              try {
                // 构建目标路径：outputDir/folderName/subFolderName
                Path targetPath = targetFolder.resolve(srcPath.getFileName());

=======
      try (Stream<Path> paths = Files.list(srcFolder)) {
        paths.filter(Files::isDirectory)  // 只处理目录
            .filter(path -> !FileUtils.isDirectoryEmpty(path))  // 只复制非空目录
            .forEach(srcPath -> {
              try {
                // 构建目标路径：outputDir/folderName/subFolderName
                Path targetPath = outputDir.resolve(folderName).resolve(srcPath.getFileName());
                
>>>>>>> 0ee3959d6b85a6244535efdf7a63de80c9f0fab4
                // 递归复制整个目录
                copyDirectoryRecursively(srcPath, targetPath);
                logger.info("已复制文件夹: {} -> {}", srcPath, targetPath);
              } catch (IOException e) {
                logger.error("复制文件夹失败: {} -> {}, 错误: {}",
<<<<<<< HEAD
                    srcPath, targetFolder, e.getMessage());
=======
                    srcPath, outputDir.resolve(folderName), e.getMessage());
>>>>>>> 0ee3959d6b85a6244535efdf7a63de80c9f0fab4
              }
            });
      } catch (IOException e) {
        logger.error("遍历文件夹失败: {}, 错误: {}", srcFolder, e.getMessage());
      }
    }
  }

  /**
   * 递归复制目录
   * 
   * @param source 源目录
   * @param target 目标目录
   * @throws IOException IO异常
   */
  private void copyDirectoryRecursively(Path source, Path target) throws IOException {
    Files.walk(source)
        .forEach(sourcePath -> {
          try {
            Path targetPath = target.resolve(source.relativize(sourcePath));
            if (Files.isDirectory(sourcePath)) {
              Files.createDirectories(targetPath);
            } else {
              Files.createDirectories(targetPath.getParent());
              Files.copy(sourcePath, targetPath, StandardCopyOption.REPLACE_EXISTING);
            }
          } catch (IOException e) {
            logger.error("复制文件失败: {} -> {}, 错误: {}", sourcePath, target, e.getMessage());
          }
        });
  }

  /**
   * 创建以SN为名的文件夹，并复制指定的文件夹
<<<<<<< HEAD
   *
   * 
   * @param sourceDir    源目录路径（包含anr、system等文件夹的目录）
   * @param snFolderPath 目标SN文件夹路径
   * @return 创建的SN文件夹路径
   */
  public Path createSnFolderAndCopyFiles(Path sourceDir, Path snFolderPath) {
    try {
      // 创建以SN为名的文件夹
      if (Files.exists(snFolderPath)) {
        // 如果文件夹已存在，先删除
        deleteDirectoryRecursively(snFolderPath);
      }
      Files.createDirectories(snFolderPath);
      logger.info("创建SN文件夹: {}", snFolderPath);

      // 复制有用文件夹：anr、system/aee_exp、system/anr
      copySnUsefulFolders(sourceDir, snFolderPath);

      return snFolderPath;
=======
   * 仿照实习生Python实现的思路
   * 
   * @param sourceDir 源目录路径（包含anr、system等文件夹的目录）
   * @param sn 设备SN号，作为新文件夹的名称
   * @return 创建的SN文件夹路径
   */
  public Path createSnFolderAndCopyFiles(Path sourceDir, String sn) {
    try {
      // 创建以SN为名的文件夹
      Path snFolder = sourceDir.resolve(sn);
      if (Files.exists(snFolder)) {
        // 如果文件夹已存在，先删除
        deleteDirectoryRecursively(snFolder);
      }
      Files.createDirectories(snFolder);
      logger.info("创建SN文件夹: {}", snFolder);

      // 复制有用文件夹：anr、system/aee_exp、system/anr
      copySnUsefulFolders(sourceDir, snFolder);

      return snFolder;
>>>>>>> 0ee3959d6b85a6244535efdf7a63de80c9f0fab4
    } catch (Exception e) {
      logger.error("创建SN文件夹失败: {}", e.getMessage(), e);
      throw new RuntimeException("创建SN文件夹失败", e);
    }
  }

  /**
   * 复制有用的文件夹到SN文件夹中
<<<<<<< HEAD
   *
=======
   * 仿照实习生Python实现的逻辑
   * 
>>>>>>> 0ee3959d6b85a6244535efdf7a63de80c9f0fab4
   * @param sourceDir 源目录
   * @param targetDir 目标SN文件夹
   */
  public void copySnUsefulFolders(Path sourceDir, Path targetDir) {
    try {
      // 1. 复制anr文件夹（如果存在）
      Path anrSource = sourceDir.resolve("anr");
      if (Files.exists(anrSource) && Files.isDirectory(anrSource)) {
        Path anrTarget = targetDir.resolve("anr");
        copyDirectoryRecursively(anrSource, anrTarget);
        logger.info("已复制anr文件夹: {} -> {}", anrSource, anrTarget);
      } else {
        logger.info("anr文件夹不存在，跳过复制");
      }

      // 2. 创建system文件夹
      Path systemTarget = targetDir.resolve("system");
      Files.createDirectories(systemTarget);

      // 3. 复制system/aee_exp文件夹（如果存在）
      Path aeeExpSource = sourceDir.resolve("system").resolve("aee_exp");
      if (Files.exists(aeeExpSource) && Files.isDirectory(aeeExpSource)) {
        Path aeeExpTarget = systemTarget.resolve("aee_exp");
        copyDirectoryRecursively(aeeExpSource, aeeExpTarget);
        logger.info("已复制system/aee_exp文件夹: {} -> {}", aeeExpSource, aeeExpTarget);
      } else {
        // 如果不存在，创建空文件夹
        Path aeeExpTarget = systemTarget.resolve("aee_exp");
        Files.createDirectories(aeeExpTarget);
        logger.info("system/aee_exp文件夹不存在，创建空文件夹: {}", aeeExpTarget);
      }

      // 4. 复制system/anr文件夹（如果存在）
      Path systemAnrSource = sourceDir.resolve("system").resolve("anr");
      if (Files.exists(systemAnrSource) && Files.isDirectory(systemAnrSource)) {
        Path systemAnrTarget = systemTarget.resolve("anr");
        copyDirectoryRecursively(systemAnrSource, systemAnrTarget);
        logger.info("已复制system/anr文件夹: {} -> {}", systemAnrSource, systemAnrTarget);
      } else {
        // 如果不存在，创建空文件夹
        Path systemAnrTarget = systemTarget.resolve("anr");
        Files.createDirectories(systemAnrTarget);
        logger.info("system/anr文件夹不存在，创建空文件夹: {}", systemAnrTarget);
      }

    } catch (Exception e) {
      logger.error("复制文件夹失败: {}", e.getMessage(), e);
      throw new RuntimeException("复制文件夹失败", e);
    }
  }

<<<<<<< HEAD
=======

>>>>>>> 0ee3959d6b85a6244535efdf7a63de80c9f0fab4
  /**
   * 递归删除目录
   */
  private void deleteDirectoryRecursively(Path directory) throws IOException {
    if (Files.exists(directory)) {
      Files.walk(directory)
          .sorted(Comparator.reverseOrder())
          .forEach(path -> {
            try {
              Files.delete(path);
            } catch (IOException e) {
              logger.error("删除文件失败: {}", path, e);
            }
          });
    }
  }

  /**
   * 处理ANR文件夹中的日志（模仿 Python 的 process_anr_folder 函数）
   * 
   * 这个方法的核心功能：
   * 1. 遍历 anr/ 目录下的所有子目录
<<<<<<< HEAD
   * 2. 统计慢方法数量并格式化输出
   * 3. 处理tmlog.tm和block_XXX_blockinfo.txt文件
   * 4. 按照新的格式要求输出ANR日志
=======
   * 2， 拼接zlog下面的文件名后加上慢方法:
   * 3.1 如果anr下面是文件是tmlog.tm,这边找到的规律是固定要第12-16行，如果是17行是线程采集的堆栈，下面就是有具体的多少行异常信息，这样的也要提取
   * 3.2看了30台机器的文件，找规律得只有A开头的学练机的anr里面可能文件是block_一串数字_blockinfo.txt以首尾为判断依据，判断是否有这个文件来截取
   * 3.2.1发现如果有block_一串数字_blockinfo.txt这个文件，这个文件一定就是从第3行开始出现有用的具体多少行的信息，所以直接从第三行开始截取，截取到文件结束
>>>>>>> 0ee3959d6b85a6244535efdf7a63de80c9f0fab4
   * 
   * @param folderPath ANR文件夹路径（D:/ANR-WORK/<设备SN>/anr）
   * @param outputFile 输出文件路径（D:/ANR-WORK/tmp_log.txt）
   */
  public void processAnrFolder(Path folderPath, Path outputFile) {
    try {
      logger.info("开始处理 ANR 文件夹: {}", folderPath);
      List<String> allContents = new ArrayList<>();

<<<<<<< HEAD
      // 统计anr文件夹下的子目录数量（慢方法数量）
      int slowMethodCount = 0;
      List<String> slowMethodNames = new ArrayList<>();

      if (Files.exists(folderPath)) {
        try (Stream<Path> paths = Files.list(folderPath)) {
          slowMethodNames = paths.filter(Files::isDirectory)
              .map(path -> path.getFileName().toString())
              .collect(java.util.stream.Collectors.toList());
          slowMethodCount = slowMethodNames.size();
          logger.info("ANR文件夹检查: {} 存在，找到 {} 个子目录: {}", folderPath, slowMethodCount, slowMethodNames);
        } catch (IOException e) {
          logger.warn("检查anr文件夹内容失败: {}", e.getMessage());
          slowMethodCount = 0;
        }
      } else {
        logger.info("ANR文件夹不存在: {}", folderPath);
        slowMethodCount = 0;
      }

      // 创建final变量供lambda表达式使用
      final int finalSlowMethodCount = slowMethodCount;

      // 检查是否有ANR日志 - 基于慢方法数量判断
      boolean hasAnrLogs = slowMethodCount > 0;

      // 添加开头判断和慢方法统计
      logger.info("ANR检测结果: hasAnrLogs={}, slowMethodCount={}", hasAnrLogs, slowMethodCount);
      if (hasAnrLogs) {
        allContents.add("有ANR日志，试用无卡顿");
        // 添加慢方法数量统计
        allContents.add("共有" + slowMethodCount + "个慢方法:");
        allContents.add(""); // 空行
        logger.info("添加有ANR日志内容");
      } else {
        allContents.add("无ANR日志，试用无卡顿");
        // 无ANR日志时不需要慢方法统计
        logger.info("添加无ANR日志内容");
      }
=======
      // 检查是否有ANR日志
      boolean hasAnrLogs = false;
      
      // 检查zlog/anr目录是否存在
      Path zlogAnrPath = folderPath.getParent().resolve("zlog").resolve("anr");
      if (Files.exists(zlogAnrPath)) {
        hasAnrLogs = true;
      }
      
      // 检查system/anr目录下是否有anr_开头的文件
      Path systemAnrPath = folderPath.getParent().resolve("system").resolve("anr");
      if (Files.exists(systemAnrPath)) {
        try (Stream<Path> anrFiles = Files.list(systemAnrPath)) {
          if (anrFiles.anyMatch(path -> path.getFileName().toString().startsWith("anr_"))) {
            hasAnrLogs = true;
          }
        }
      }
      
      // 添加开头判断
      if (hasAnrLogs) {
        allContents.add("有ANR日志");
      } else {
        allContents.add("试用无卡顿");
      }
      allContents.add(""); // 空行
>>>>>>> 0ee3959d6b85a6244535efdf7a63de80c9f0fab4

      // 遍历 anr/ 目录下的所有子目录
      try (Stream<Path> paths = Files.list(folderPath)) {
        paths.filter(Files::isDirectory)
            .forEach(entry -> {
              try {
                String entryName = entry.getFileName().toString();
                logger.info("处理子目录: {}", entryName);
<<<<<<< HEAD

                // 添加目录标题，格式：方法名,慢方法(x个慢方法):
                allContents.add(entryName + ",慢方法(" + finalSlowMethodCount + "个慢方法):");

=======
                
                // 添加目录标题
                allContents.add(entryName + "慢方法:");
                
>>>>>>> 0ee3959d6b85a6244535efdf7a63de80c9f0fab4
                // 处理当前目录下的所有日志文件（tmlog.tm 和 block_XXX_blockinfo.txt）
                try (Stream<Path> logFiles = Files.walk(entry)) {
                  logFiles.filter(path -> {
                    String fileName = path.getFileName().toString();
<<<<<<< HEAD
                    return fileName.equals("tmlog.tm") ||
                        (fileName.startsWith("block_") && fileName.endsWith("_blockinfo.txt"));
=======
                    return fileName.equals("tmlog.tm") || 
                           (fileName.startsWith("block_") && fileName.endsWith("_blockinfo.txt"));
>>>>>>> 0ee3959d6b85a6244535efdf7a63de80c9f0fab4
                  })
                      .forEach(logFile -> {
                        try {
                          logger.debug("处理日志文件: {}", logFile);
                          List<String> lines = Files.readAllLines(logFile);
                          String fileName = logFile.getFileName().toString();
<<<<<<< HEAD

=======
                          
>>>>>>> 0ee3959d6b85a6244535efdf7a63de80c9f0fab4
                          if (fileName.equals("tmlog.tm")) {
                            // 处理 tmlog.tm 文件
                            if (lines.size() >= 17) {
                              // 提取基础性能信息（第12-16行）
<<<<<<< HEAD
                              allContents.add(lines.get(11).trim()); // 消息执行耗时: 0ms
                              allContents.add(lines.get(12).trim()); // 页面类：default
                              allContents.add(lines.get(13).trim()); // 剩余内存：1978MB, 总内存：5885MB ,是否低内存：否
                              allContents.add(lines.get(14).trim()); // 应用CPU占比：0.00%, CPU 利用率：
                              allContents.add(lines.get(15).trim()); // 发生时间：1757642630614

=======
                              allContents.add(lines.get(11).trim()); // 消息执行耗时: 0ms 
                              allContents.add(lines.get(12).trim()); // 页面类：default
                              allContents.add(lines.get(13).trim()); // 剩余内存：1978MB, 总内存：5885MB ,是否低内存：否 
                              allContents.add(lines.get(14).trim()); // 应用CPU占比：0.00%, CPU 利用率：
                              allContents.add(lines.get(15).trim()); // 发生时间：1757642630614
                              
>>>>>>> 0ee3959d6b85a6244535efdf7a63de80c9f0fab4
                              // 检查第17行是否包含"线程采集的堆栈"
                              String line17 = lines.get(16).trim();
                              if (line17.contains("线程采集的堆栈")) {
                                // 提取线程堆栈信息（从第17行开始到分隔符）
                                allContents.add("线程采集的堆栈：");
<<<<<<< HEAD

=======
                                
>>>>>>> 0ee3959d6b85a6244535efdf7a63de80c9f0fab4
                                // 从第17行开始提取，直到遇到分隔符
                                for (int i = 16; i < lines.size(); i++) {
                                  String line = lines.get(i).trim();
                                  if (line.equals("========================================================")) {
                                    break; // 遇到分隔符停止
                                  }
                                  if (!line.isEmpty()) {
                                    allContents.add(line);
                                  }
                                }
                              } else if (line17.contains("核心耗时方法ID")) {
                                // 如果有核心耗时方法ID，也提取出来
                                allContents.add("核心耗时方法ID：" + line17);
                              }
                            } else {
                              logger.warn("tmlog.tm文件行数不足17行，跳过: {}", logFile);
                            }
                          } else if (fileName.startsWith("block_") && fileName.endsWith("_blockinfo.txt")) {
                            // 处理 block_XXX_blockinfo.txt 文件
                            if (lines.size() >= 3) {
                              // 从第3行开始提取到文件末尾
                              for (int i = 2; i < lines.size(); i++) {
                                String line = lines.get(i).trim();
                                if (!line.isEmpty()) {
                                  allContents.add(line);
                                }
                              }
                            } else {
                              logger.warn("blockinfo.txt文件行数不足3行，跳过: {}", logFile);
                            }
                          }
<<<<<<< HEAD

=======
                          
>>>>>>> 0ee3959d6b85a6244535efdf7a63de80c9f0fab4
                          // 添加5个空行分隔不同慢方法的内容
                          for (int i = 0; i < 5; i++) {
                            allContents.add("");
                          }
                        } catch (IOException e) {
                          logger.error("读取文件失败: {}", logFile, e);
                        } catch (Exception e) {
                          logger.error("处理文件 {} 时出错: {}", logFile, e.getMessage());
                        }
                      });
                }

              } catch (Exception e) {
                logger.error("处理目录 {} 时出错: {}", entry, e.getMessage());
              }
            });
      }

      // 将提取的内容写入输出文件
      Files.write(outputFile, allContents);
<<<<<<< HEAD
      logger.info("ANR 日志处理完成，生成报告: {} (共 {} 行，{} 个慢方法)",
          outputFile, allContents.size(), slowMethodCount);
=======
      logger.info("ANR 日志处理完成，生成报告: {} (共 {} 行)", outputFile, allContents.size());
>>>>>>> 0ee3959d6b85a6244535efdf7a63de80c9f0fab4

    } catch (Exception e) {
      logger.error("处理ANR文件夹时出错: {}", e.getMessage());
    }
  }

  /**
<<<<<<< HEAD
   * 生成无ANR日志的报告文件
   * 
   * @param outputFile 输出文件路径
   */
  public void generateNoAnrReport(Path outputFile) {
    try {
      logger.info("生成无ANR日志报告: {}", outputFile);

      // 确保输出目录存在
      Files.createDirectories(outputFile.getParent());

      // 创建报告内容
      List<String> reportContent = new ArrayList<>();
      reportContent.add("无ANR日志，试用无卡顿");

      // 写入文件
      Files.write(outputFile, reportContent);
      logger.info("无ANR日志报告已生成: {} (共 {} 行)", outputFile, reportContent.size());

    } catch (Exception e) {
      logger.error("生成无ANR日志报告失败: {}", e.getMessage());
    }
  }

  /**
=======
>>>>>>> 0ee3959d6b85a6244535efdf7a63de80c9f0fab4
   * 获取生成的文件列表
   * 
   * @param outputDir 输出目录
   * @return 文件列表
   */
  public List<String> getGeneratedFiles(Path outputDir) {
    List<String> files = new ArrayList<>();

    try (Stream<Path> paths = Files.walk(outputDir)) {
      paths.filter(Files::isRegularFile)
          .forEach(path -> {
            String relativePath = outputDir.relativize(path).toString();
            files.add(relativePath);
          });
    } catch (IOException e) {
      logger.error("获取生成文件列表失败: {}", e.getMessage());
    }

    return files;
  }

  /**
   * 检查输出目录是否存在且包含文件
   * 
   * @param outputDir 输出目录
   * @return 是否有效
   */
  public boolean isValidOutputDirectory(Path outputDir) {
    return Files.exists(outputDir) && !FileUtils.isDirectoryEmpty(outputDir);
  }
}
